package com.design.pattern.principle.improve;

import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.Comparator;
import java.util.function.BiConsumer;

public class InterfaceSegregation1 {
    public static void main(String[] args) throws Exception {
        //A通过接口依赖B
        B b = new B();
        //C类通过接口依赖D（依赖即使用）
        D d = new D();
        BiConsumer<String, Interface1> call = (clz, para) -> {
            try {
                Class<?> aClass = Class.forName(clz);
                Object o = aClass.newInstance();
                Method[] declaredMethods = aClass.getDeclaredMethods();
                Arrays.sort(declaredMethods, Comparator.comparing(Method::getName));
                for (Method declaredMethod : declaredMethods) {
                    if (declaredMethod.getName().contains("depend")) {
                        declaredMethod.invoke(o, para);
                    }
                }
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        };
        System.out.println("执行A的全部方法");
        call.accept("com.design.pattern.principle.improve.A", b);
        System.out.println("执行C的全部方法");
        call.accept("com.design.pattern.principle.improve.C", d);
    }
}

/**
 * 接口1
 * 1. B类和D类都实现了接口里面的五个方法，但是A只用到了B的1 2 3，C只用到了D的1 4 5，B和D都多实现了两个方法
 * 2. 按照隔离原则，需要将接口Interface1 拆分成多个接口，建立在最小接口上进行拆解。
 * 3. 需要将interface1中出现的方法，根据据实际情况拆分为三个接口。
 */
interface Interface1 {
    void operation1();
}

interface Interface2 {
    void operation2();

    void operation3();
}

interface Interface3 {
    void operation4();

    void operation5();
}

class B implements Interface1, Interface2 {

    @Override
    public void operation1() {
        System.out.println("B 中实现了operation1");
    }

    @Override
    public void operation2() {
        System.out.println("B 中实现了operation2");
    }

    @Override
    public void operation3() {
        System.out.println("B 中实现了operation3");
    }

}

class D implements Interface1, Interface3 {

    @Override
    public void operation1() {
        System.out.println("D 中实现了operation1");
    }

    @Override
    public void operation4() {
        System.out.println("D 中实现了operation4");
    }

    @Override
    public void operation5() {
        System.out.println("D 中实现了operation5");
    }
}

/**
 * 然后类A通过接口依赖B，会使用到B，用到1 2 3方法，但是B必须要实现1 2 3 4 5方法。
 */
class A {
    public void depend1(Interface1 i) {
        i.operation1();
    }

    public void depend2(Interface2 i) {
        i.operation2();
    }

    public void depend3(Interface2 i) {
        i.operation3();
    }
}

/**
 * 类C通过接口依赖D，会使用到D的1 3 4方法，但是D必须要实现1 2 3 4 5方法。
 */
class C {
    public void depend1(Interface1 i) {
        i.operation1();
    }

    public void depend4(Interface3 i) {
        i.operation4();
    }

    public void depend5(Interface3 i) {
        i.operation5();
    }
}